package abs.service;

import abs.dao.CompaniasDAO;
import abs.dao.DocumentosDAO;
import abs.dao.GrupoClientesDAO;
import abs.dao.GrupoProveedoresDAO;
import abs.dao.ProveedoresDAO;
import abs.dao.RetencionesDAO;
import abs.dao.SucursalesDAO;
import abs.dao.TipoClientesDAO;
import abs.dao.TipoProveedoresDAO;

import abs.domain.Companias;
import abs.domain.Documentos;
import abs.domain.GrupoClientes;
import abs.domain.GrupoProveedores;
import abs.domain.Proveedores;
import abs.domain.Retenciones;
import abs.domain.Sucursales;
import abs.domain.TipoClientes;
import abs.domain.TipoProveedores;

import java.util.List;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

/**
 * Spring service that handles CRUD requests for Companias entities
 * 
 */

@Service("CompaniasService")
@Transactional
public class CompaniasServiceImpl implements CompaniasService {

	/**
	 * DAO injected by Spring that manages Companias entities
	 * 
	 */
	@Autowired
	private CompaniasDAO companiasDAO;

	/**
	 * DAO injected by Spring that manages Documentos entities
	 * 
	 */
	@Autowired
	private DocumentosDAO documentosDAO;

	/**
	 * DAO injected by Spring that manages GrupoClientes entities
	 * 
	 */
	@Autowired
	private GrupoClientesDAO grupoClientesDAO;

	/**
	 * DAO injected by Spring that manages GrupoProveedores entities
	 * 
	 */
	@Autowired
	private GrupoProveedoresDAO grupoProveedoresDAO;

	/**
	 * DAO injected by Spring that manages Proveedores entities
	 * 
	 */
	@Autowired
	private ProveedoresDAO proveedoresDAO;

	/**
	 * DAO injected by Spring that manages Retenciones entities
	 * 
	 */
	@Autowired
	private RetencionesDAO retencionesDAO;

	/**
	 * DAO injected by Spring that manages Sucursales entities
	 * 
	 */
	@Autowired
	private SucursalesDAO sucursalesDAO;

	/**
	 * DAO injected by Spring that manages TipoClientes entities
	 * 
	 */
	@Autowired
	private TipoClientesDAO tipoClientesDAO;

	/**
	 * DAO injected by Spring that manages TipoProveedores entities
	 * 
	 */
	@Autowired
	private TipoProveedoresDAO tipoProveedoresDAO;

	/**
	 * Instantiates a new CompaniasServiceImpl.
	 *
	 */
	public CompaniasServiceImpl() {
	}

	/**
	 * Save an existing Sucursales entity
	 * 
	 */
	@Transactional
	public Companias saveCompaniasSucursaleses(String co000nocia, Sucursales related_sucursaleses) {
		Companias companias = companiasDAO.findCompaniasByPrimaryKey(co000nocia, -1, -1);
		Sucursales existingsucursaleses = sucursalesDAO.findSucursalesByPrimaryKey(related_sucursaleses.getCo001cdgo());

		// copy into the existing record to preserve existing relationships
		if (existingsucursaleses != null) {
			existingsucursaleses.setCo001cdgo(related_sucursaleses.getCo001cdgo());
			existingsucursaleses.setCo001nomb(related_sucursaleses.getCo001nomb());
			existingsucursaleses.setCo001esta(related_sucursaleses.getCo001esta());
			existingsucursaleses.setCo001load(related_sucursaleses.getCo001load());
			existingsucursaleses.setCo001fead(related_sucursaleses.getCo001fead());
			existingsucursaleses.setCo001lomo(related_sucursaleses.getCo001lomo());
			existingsucursaleses.setCo001femo(related_sucursaleses.getCo001femo());
			related_sucursaleses = existingsucursaleses;
		}

		related_sucursaleses.setCompanias(companias);
		companias.getSucursaleses().add(related_sucursaleses);
		related_sucursaleses = sucursalesDAO.store(related_sucursaleses);
		sucursalesDAO.flush();

		companias = companiasDAO.store(companias);
		companiasDAO.flush();

		return companias;
	}

	/**
	 */
	@Transactional
	public Companias findCompaniasByPrimaryKey(String co000nocia) {
		return companiasDAO.findCompaniasByPrimaryKey(co000nocia);
	}

	/**
	 * Save an existing Retenciones entity
	 * 
	 */
	@Transactional
	public Companias saveCompaniasRetencioneses(String co000nocia, Retenciones related_retencioneses) {
		Companias companias = companiasDAO.findCompaniasByPrimaryKey(co000nocia, -1, -1);
		Retenciones existingretencioneses = retencionesDAO.findRetencionesByPrimaryKey(related_retencioneses.getRt100cdgo());

		// copy into the existing record to preserve existing relationships
		if (existingretencioneses != null) {
			existingretencioneses.setRt100cdgo(related_retencioneses.getRt100cdgo());
			existingretencioneses.setRt100desc(related_retencioneses.getRt100desc());
			existingretencioneses.setRt100tipo(related_retencioneses.getRt100tipo());
			existingretencioneses.setRt100niv1(related_retencioneses.getRt100niv1());
			existingretencioneses.setRt100niv2(related_retencioneses.getRt100niv2());
			existingretencioneses.setRt100niv3(related_retencioneses.getRt100niv3());
			existingretencioneses.setRt100niv4(related_retencioneses.getRt100niv4());
			existingretencioneses.setRt100niv5(related_retencioneses.getRt100niv5());
			existingretencioneses.setRt100ctac(related_retencioneses.getRt100ctac());
			existingretencioneses.setRt100porc(related_retencioneses.getRt100porc());
			existingretencioneses.setRt100timo(related_retencioneses.getRt100timo());
			existingretencioneses.setRt100esta(related_retencioneses.getRt100esta());
			existingretencioneses.setRt100load(related_retencioneses.getRt100load());
			existingretencioneses.setRt100fead(related_retencioneses.getRt100fead());
			existingretencioneses.setRt100lomo(related_retencioneses.getRt100lomo());
			existingretencioneses.setRt100femo(related_retencioneses.getRt100femo());
			related_retencioneses = existingretencioneses;
		}

		related_retencioneses.setCompanias(companias);
		companias.getRetencioneses().add(related_retencioneses);
		related_retencioneses = retencionesDAO.store(related_retencioneses);
		retencionesDAO.flush();

		companias = companiasDAO.store(companias);
		companiasDAO.flush();

		return companias;
	}

	/**
	 * Delete an existing GrupoProveedores entity
	 * 
	 */
	@Transactional
	public Companias deleteCompaniasGrupoProveedoreses(String companias_co000nocia, String related_grupoproveedoreses_grppr100cdgo) {
		GrupoProveedores related_grupoproveedoreses = grupoProveedoresDAO.findGrupoProveedoresByPrimaryKey(related_grupoproveedoreses_grppr100cdgo, -1, -1);

		Companias companias = companiasDAO.findCompaniasByPrimaryKey(companias_co000nocia, -1, -1);

		related_grupoproveedoreses.setCompanias(null);
		companias.getGrupoProveedoreses().remove(related_grupoproveedoreses);

		grupoProveedoresDAO.remove(related_grupoproveedoreses);
		grupoProveedoresDAO.flush();

		return companias;
	}

	/**
	 * Save an existing GrupoClientes entity
	 * 
	 */
	@Transactional
	public Companias saveCompaniasGrupoClienteses(String co000nocia, GrupoClientes related_grupoclienteses) {
		Companias companias = companiasDAO.findCompaniasByPrimaryKey(co000nocia, -1, -1);
		GrupoClientes existinggrupoClienteses = grupoClientesDAO.findGrupoClientesByPrimaryKey(related_grupoclienteses.getGrpcl100cdgo());

		// copy into the existing record to preserve existing relationships
		if (existinggrupoClienteses != null) {
			existinggrupoClienteses.setGrpcl100cdgo(related_grupoclienteses.getGrpcl100cdgo());
			existinggrupoClienteses.setGrpcl100name(related_grupoclienteses.getGrpcl100name());
			existinggrupoClienteses.setGrpcl100clas(related_grupoclienteses.getGrpcl100clas());
			existinggrupoClienteses.setGrpcl100esta(related_grupoclienteses.getGrpcl100esta());
			existinggrupoClienteses.setGrpcl100load(related_grupoclienteses.getGrpcl100load());
			existinggrupoClienteses.setGrpcl100fead(related_grupoclienteses.getGrpcl100fead());
			existinggrupoClienteses.setGrpcl100lomo(related_grupoclienteses.getGrpcl100lomo());
			existinggrupoClienteses.setGrpcl100femo(related_grupoclienteses.getGrpcl100femo());
			related_grupoclienteses = existinggrupoClienteses;
		}

		related_grupoclienteses.setCompanias(companias);
		companias.getGrupoClienteses().add(related_grupoclienteses);
		related_grupoclienteses = grupoClientesDAO.store(related_grupoclienteses);
		grupoClientesDAO.flush();

		companias = companiasDAO.store(companias);
		companiasDAO.flush();

		return companias;
	}

	/**
	 * Delete an existing Companias entity
	 * 
	 */
	@Transactional
	public void deleteCompanias(Companias companias) {
		companiasDAO.remove(companias);
		companiasDAO.flush();
	}

	/**
	 * Delete an existing TipoClientes entity
	 * 
	 */
	@Transactional
	public Companias deleteCompaniasTipoClienteses(String companias_co000nocia, String related_tipoclienteses_tipocl100cdgo) {
		TipoClientes related_tipoclienteses = tipoClientesDAO.findTipoClientesByPrimaryKey(related_tipoclienteses_tipocl100cdgo, -1, -1);

		Companias companias = companiasDAO.findCompaniasByPrimaryKey(companias_co000nocia, -1, -1);

		related_tipoclienteses.setCompanias(null);
		companias.getTipoClienteses().remove(related_tipoclienteses);

		tipoClientesDAO.remove(related_tipoclienteses);
		tipoClientesDAO.flush();

		return companias;
	}

	/**
	 * Save an existing Proveedores entity
	 * 
	 */
	@Transactional
	public Companias saveCompaniasProveedoreses(String co000nocia, Proveedores related_proveedoreses) {
		Companias companias = companiasDAO.findCompaniasByPrimaryKey(co000nocia, -1, -1);
		Proveedores existingproveedoreses = proveedoresDAO.findProveedoresByPrimaryKey(related_proveedoreses.getPr100copr());

		// copy into the existing record to preserve existing relationships
		if (existingproveedoreses != null) {
			existingproveedoreses.setPr100copr(related_proveedoreses.getPr100copr());
			existingproveedoreses.setPr100ruc(related_proveedoreses.getPr100ruc());
			existingproveedoreses.setPr100nomb(related_proveedoreses.getPr100nomb());
			existingproveedoreses.setPr100ciud(related_proveedoreses.getPr100ciud());
			existingproveedoreses.setPr100dire(related_proveedoreses.getPr100dire());
			existingproveedoreses.setPr100telf(related_proveedoreses.getPr100telf());
			existingproveedoreses.setPr100emai(related_proveedoreses.getPr100emai());
			existingproveedoreses.setPr100rele(related_proveedoreses.getPr100rele());
			existingproveedoreses.setPr100cgre(related_proveedoreses.getPr100cgre());
			existingproveedoreses.setPr100auto(related_proveedoreses.getPr100auto());
			existingproveedoreses.setPr100cont(related_proveedoreses.getPr100cont());
			existingproveedoreses.setPr100tar(related_proveedoreses.getPr100tar());
			existingproveedoreses.setPr100obs(related_proveedoreses.getPr100obs());
			existingproveedoreses.setPr100obs2(related_proveedoreses.getPr100obs2());
			existingproveedoreses.setPr100plaz(related_proveedoreses.getPr100plaz());
			existingproveedoreses.setPr100ctadb(related_proveedoreses.getPr100ctadb());
			existingproveedoreses.setPr100ctacr(related_proveedoreses.getPr100ctacr());
			existingproveedoreses.setPr100load(related_proveedoreses.getPr100load());
			existingproveedoreses.setPr100fead(related_proveedoreses.getPr100fead());
			existingproveedoreses.setPr100lomo(related_proveedoreses.getPr100lomo());
			existingproveedoreses.setPr100femo(related_proveedoreses.getPr100femo());
			related_proveedoreses = existingproveedoreses;
		}

		related_proveedoreses.setCompanias(companias);
		companias.getProveedoreses().add(related_proveedoreses);
		related_proveedoreses = proveedoresDAO.store(related_proveedoreses);
		proveedoresDAO.flush();

		companias = companiasDAO.store(companias);
		companiasDAO.flush();

		return companias;
	}

	/**
	 * Load an existing Companias entity
	 * 
	 */
	@Transactional
	public Set<Companias> loadCompaniass() {
		return companiasDAO.findAllCompaniass();
	}

	/**
	 * Delete an existing GrupoClientes entity
	 * 
	 */
	@Transactional
	public Companias deleteCompaniasGrupoClienteses(String companias_co000nocia, String related_grupoclienteses_grpcl100cdgo) {
		GrupoClientes related_grupoclienteses = grupoClientesDAO.findGrupoClientesByPrimaryKey(related_grupoclienteses_grpcl100cdgo, -1, -1);

		Companias companias = companiasDAO.findCompaniasByPrimaryKey(companias_co000nocia, -1, -1);

		related_grupoclienteses.setCompanias(null);
		companias.getGrupoClienteses().remove(related_grupoclienteses);

		grupoClientesDAO.remove(related_grupoclienteses);
		grupoClientesDAO.flush();

		return companias;
	}

	/**
	 * Save an existing GrupoProveedores entity
	 * 
	 */
	@Transactional
	public Companias saveCompaniasGrupoProveedoreses(String co000nocia, GrupoProveedores related_grupoproveedoreses) {
		Companias companias = companiasDAO.findCompaniasByPrimaryKey(co000nocia, -1, -1);
		GrupoProveedores existinggrupoProveedoreses = grupoProveedoresDAO.findGrupoProveedoresByPrimaryKey(related_grupoproveedoreses.getGrppr100cdgo());

		// copy into the existing record to preserve existing relationships
		if (existinggrupoProveedoreses != null) {
			existinggrupoProveedoreses.setGrppr100cdgo(related_grupoproveedoreses.getGrppr100cdgo());
			existinggrupoProveedoreses.setGrppr100name(related_grupoproveedoreses.getGrppr100name());
			existinggrupoProveedoreses.setGrppr100tipo(related_grupoproveedoreses.getGrppr100tipo());
			existinggrupoProveedoreses.setGrppr100clas(related_grupoproveedoreses.getGrppr100clas());
			existinggrupoProveedoreses.setGrppr100esta(related_grupoproveedoreses.getGrppr100esta());
			existinggrupoProveedoreses.setGrppr100load(related_grupoproveedoreses.getGrppr100load());
			existinggrupoProveedoreses.setGrppr100fead(related_grupoproveedoreses.getGrppr100fead());
			existinggrupoProveedoreses.setGrppr100lomo(related_grupoproveedoreses.getGrppr100lomo());
			existinggrupoProveedoreses.setGrppr100femo(related_grupoproveedoreses.getGrppr100femo());
			related_grupoproveedoreses = existinggrupoProveedoreses;
		}

		related_grupoproveedoreses.setCompanias(companias);
		companias.getGrupoProveedoreses().add(related_grupoproveedoreses);
		related_grupoproveedoreses = grupoProveedoresDAO.store(related_grupoproveedoreses);
		grupoProveedoresDAO.flush();

		companias = companiasDAO.store(companias);
		companiasDAO.flush();

		return companias;
	}

	/**
	 * Delete an existing Sucursales entity
	 * 
	 */
	@Transactional
	public Companias deleteCompaniasSucursaleses(String companias_co000nocia, String related_sucursaleses_co001cdgo) {
		Sucursales related_sucursaleses = sucursalesDAO.findSucursalesByPrimaryKey(related_sucursaleses_co001cdgo, -1, -1);

		Companias companias = companiasDAO.findCompaniasByPrimaryKey(companias_co000nocia, -1, -1);

		related_sucursaleses.setCompanias(null);
		companias.getSucursaleses().remove(related_sucursaleses);

		sucursalesDAO.remove(related_sucursaleses);
		sucursalesDAO.flush();

		return companias;
	}

	/**
	 * Return a count of all Companias entity
	 * 
	 */
	@Transactional
	public Integer countCompaniass() {
		return ((Long) companiasDAO.createQuerySingleResult("select count(o) from Companias o").getSingleResult()).intValue();
	}

	/**
	 * Delete an existing TipoProveedores entity
	 * 
	 */
	@Transactional
	public Companias deleteCompaniasTipoProveedoreses(String companias_co000nocia, String related_tipoproveedoreses_tipopr100cdgo) {
		TipoProveedores related_tipoproveedoreses = tipoProveedoresDAO.findTipoProveedoresByPrimaryKey(related_tipoproveedoreses_tipopr100cdgo, -1, -1);

		Companias companias = companiasDAO.findCompaniasByPrimaryKey(companias_co000nocia, -1, -1);

		related_tipoproveedoreses.setCompanias(null);
		companias.getTipoProveedoreses().remove(related_tipoproveedoreses);

		tipoProveedoresDAO.remove(related_tipoproveedoreses);
		tipoProveedoresDAO.flush();

		return companias;
	}

	/**
	 * Save an existing TipoProveedores entity
	 * 
	 */
	@Transactional
	public Companias saveCompaniasTipoProveedoreses(String co000nocia, TipoProveedores related_tipoproveedoreses) {
		Companias companias = companiasDAO.findCompaniasByPrimaryKey(co000nocia, -1, -1);
		TipoProveedores existingtipoProveedoreses = tipoProveedoresDAO.findTipoProveedoresByPrimaryKey(related_tipoproveedoreses.getTipopr100cdgo());

		// copy into the existing record to preserve existing relationships
		if (existingtipoProveedoreses != null) {
			existingtipoProveedoreses.setTipopr100cdgo(related_tipoproveedoreses.getTipopr100cdgo());
			existingtipoProveedoreses.setTipopr100desc(related_tipoproveedoreses.getTipopr100desc());
			existingtipoProveedoreses.setTipopr100esta(related_tipoproveedoreses.getTipopr100esta());
			existingtipoProveedoreses.setTipopr100load(related_tipoproveedoreses.getTipopr100load());
			existingtipoProveedoreses.setTipopr100fead(related_tipoproveedoreses.getTipopr100fead());
			existingtipoProveedoreses.setTipopr100lomo(related_tipoproveedoreses.getTipopr100lomo());
			existingtipoProveedoreses.setTipopr100femo(related_tipoproveedoreses.getTipopr100femo());
			related_tipoproveedoreses = existingtipoProveedoreses;
		}

		related_tipoproveedoreses.setCompanias(companias);
		companias.getTipoProveedoreses().add(related_tipoproveedoreses);
		related_tipoproveedoreses = tipoProveedoresDAO.store(related_tipoproveedoreses);
		tipoProveedoresDAO.flush();

		companias = companiasDAO.store(companias);
		companiasDAO.flush();

		return companias;
	}

	/**
	 * Save an existing TipoClientes entity
	 * 
	 */
	@Transactional
	public Companias saveCompaniasTipoClienteses(String co000nocia, TipoClientes related_tipoclienteses) {
		Companias companias = companiasDAO.findCompaniasByPrimaryKey(co000nocia, -1, -1);
		TipoClientes existingtipoClienteses = tipoClientesDAO.findTipoClientesByPrimaryKey(related_tipoclienteses.getTipocl100cdgo());

		// copy into the existing record to preserve existing relationships
		if (existingtipoClienteses != null) {
			existingtipoClienteses.setTipocl100cdgo(related_tipoclienteses.getTipocl100cdgo());
			existingtipoClienteses.setTipocl100desc(related_tipoclienteses.getTipocl100desc());
			existingtipoClienteses.setTipocl100esta(related_tipoclienteses.getTipocl100esta());
			existingtipoClienteses.setTipocl100load(related_tipoclienteses.getTipocl100load());
			existingtipoClienteses.setTipocl100fead(related_tipoclienteses.getTipocl100fead());
			existingtipoClienteses.setTipocl100lomo(related_tipoclienteses.getTipocl100lomo());
			existingtipoClienteses.setTipocl100femo(related_tipoclienteses.getTipocl100femo());
			related_tipoclienteses = existingtipoClienteses;
		}

		related_tipoclienteses.setCompanias(companias);
		companias.getTipoClienteses().add(related_tipoclienteses);
		related_tipoclienteses = tipoClientesDAO.store(related_tipoclienteses);
		tipoClientesDAO.flush();

		companias = companiasDAO.store(companias);
		companiasDAO.flush();

		return companias;
	}

	/**
	 * Delete an existing Retenciones entity
	 * 
	 */
	@Transactional
	public Companias deleteCompaniasRetencioneses(String companias_co000nocia, String related_retencioneses_rt100cdgo) {
		Retenciones related_retencioneses = retencionesDAO.findRetencionesByPrimaryKey(related_retencioneses_rt100cdgo, -1, -1);

		Companias companias = companiasDAO.findCompaniasByPrimaryKey(companias_co000nocia, -1, -1);

		related_retencioneses.setCompanias(null);
		companias.getRetencioneses().remove(related_retencioneses);

		retencionesDAO.remove(related_retencioneses);
		retencionesDAO.flush();

		return companias;
	}

	/**
	 * Save an existing Companias entity
	 * 
	 */
	@Transactional
	public void saveCompanias(Companias companias) {
		Companias existingCompanias = companiasDAO.findCompaniasByPrimaryKey(companias.getCo000nocia());

		if (existingCompanias != null) {
			if (existingCompanias != companias) {
				existingCompanias.setCo000nocia(companias.getCo000nocia());
				existingCompanias.setCo000logo(companias.getCo000logo());
				existingCompanias.setCo000nomb(companias.getCo000nomb());
				existingCompanias.setCo000nosu(companias.getCo000nosu());
				existingCompanias.setCo000dire(companias.getCo000dire());
				existingCompanias.setCo000repr(companias.getCo000repr());
				existingCompanias.setCo000cont(companias.getCo000cont());
				existingCompanias.setCo000nreg(companias.getCo000nreg());
				existingCompanias.setCo000clca(companias.getCo000clca());
				existingCompanias.setCo000mofu(companias.getCo000mofu());
				existingCompanias.setCo000notr(companias.getCo000notr());
				existingCompanias.setCo000idtr(companias.getCo000idtr());
				existingCompanias.setCo000meci(companias.getCo000meci());
				existingCompanias.setCo000mepr(companias.getCo000mepr());
				existingCompanias.setCo000incc(companias.getCo000incc());
				existingCompanias.setCo000inut(companias.getCo000inut());
				existingCompanias.setCo000incp(companias.getCo000incp());
				existingCompanias.setCo000incf(companias.getCo000incf());
				existingCompanias.setCo000baca(companias.getCo000baca());
				existingCompanias.setCo000fir1(companias.getCo000fir1());
				existingCompanias.setCo000fir2(companias.getCo000fir2());
				existingCompanias.setCo000esta(companias.getCo000esta());
				existingCompanias.setCo000load(companias.getCo000load());
				existingCompanias.setCo000fead(companias.getCo000fead());
				existingCompanias.setCo000lomo(companias.getCo000lomo());
				existingCompanias.setCo000femo(companias.getCo000femo());
			}
			companias = companiasDAO.store(existingCompanias);
		} else {
			companias = companiasDAO.store(companias);
		}
		companiasDAO.flush();
	}

	/**
	 * Delete an existing Proveedores entity
	 * 
	 */
	@Transactional
	public Companias deleteCompaniasProveedoreses(String companias_co000nocia, Integer related_proveedoreses_pr100copr) {
		Proveedores related_proveedoreses = proveedoresDAO.findProveedoresByPrimaryKey(related_proveedoreses_pr100copr, -1, -1);

		Companias companias = companiasDAO.findCompaniasByPrimaryKey(companias_co000nocia, -1, -1);

		related_proveedoreses.setCompanias(null);
		companias.getProveedoreses().remove(related_proveedoreses);

		proveedoresDAO.remove(related_proveedoreses);
		proveedoresDAO.flush();

		return companias;
	}

	/**
	 * Return all Companias entity
	 * 
	 */
	@Transactional
	public List<Companias> findAllCompaniass(Integer startResult, Integer maxRows) {
		return new java.util.ArrayList<Companias>(companiasDAO.findAllCompaniass(startResult, maxRows));
	}

	/**
	 * Save an existing Documentos entity
	 * 
	 */
	@Transactional
	public Companias saveCompaniasDocumentoses(String co000nocia, Documentos related_documentoses) {
		Companias companias = companiasDAO.findCompaniasByPrimaryKey(co000nocia, -1, -1);
		Documentos existingdocumentoses = documentosDAO.findDocumentosByPrimaryKey(related_documentoses.getCo030codi());

		// copy into the existing record to preserve existing relationships
		if (existingdocumentoses != null) {
			existingdocumentoses.setCo030codi(related_documentoses.getCo030codi());
			existingdocumentoses.setCo030desc(related_documentoses.getCo030desc());
			existingdocumentoses.setCo030load(related_documentoses.getCo030load());
			existingdocumentoses.setCo030fead(related_documentoses.getCo030fead());
			existingdocumentoses.setCo030lomo(related_documentoses.getCo030lomo());
			existingdocumentoses.setCo030femo(related_documentoses.getCo030femo());
			related_documentoses = existingdocumentoses;
		}

		related_documentoses.setCompanias(companias);
		companias.getDocumentoses().add(related_documentoses);
		related_documentoses = documentosDAO.store(related_documentoses);
		documentosDAO.flush();

		companias = companiasDAO.store(companias);
		companiasDAO.flush();

		return companias;
	}

	/**
	 * Delete an existing Documentos entity
	 * 
	 */
	@Transactional
	public Companias deleteCompaniasDocumentoses(String companias_co000nocia, String related_documentoses_co030codi) {
		Documentos related_documentoses = documentosDAO.findDocumentosByPrimaryKey(related_documentoses_co030codi, -1, -1);

		Companias companias = companiasDAO.findCompaniasByPrimaryKey(companias_co000nocia, -1, -1);

		related_documentoses.setCompanias(null);
		companias.getDocumentoses().remove(related_documentoses);

		documentosDAO.remove(related_documentoses);
		documentosDAO.flush();

		return companias;
	}
}
